home *** CD-ROM | disk | FTP | other *** search
/ The Very Best of Atari Inside / The Very Best of Atari Inside 1.iso / sharew / accs / recorder / recorder.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-11-06  |  14.5 KB  |  513 lines
  1. /**********************************************************************
  2.    Event-Recorder V1.0   zeichnet alle Events auf und läßt sie bei +
  3.    Bedarf wieder abspielen
  4.    Tip: Speicher kann mittels SHIFT-Taste freigegeben werden.
  5.         Wiedergabegeschwindigkeit kann mit ALT geändet werden. 
  6.         Der Menuepunkt ist mit Zusatztaste anzuklicken
  7. **********************************************************************/
  8.  
  9. extern  long    gemdos();
  10. extern  long    bios();
  11.  
  12. #define Fsetdta(a)      gemdos(0x1a,a)
  13. #define Fcreate(a,b)    gemdos(0x3c,a,b)
  14. #define Fopen(a,b)      gemdos(0x3d,a,b)
  15. #define Fclose(a)       gemdos(0x3e,a)
  16. #define Fread(a,b,c)    gemdos(0x3f,a,b,c)
  17. #define Fwrite(a,b,c)   gemdos(0x40,a,b,c)
  18. #define Malloc(a)       gemdos(0x48,a)
  19. #define Mfree(a)        gemdos(0x49,a)
  20. #define Fsfirst(a,b)    (int)gemdos(0x4e,a,b)
  21. #define BING            bios(3,2,7)
  22. #define EOS             '\0'
  23. #define FALSE           0
  24. #define TRUE            1
  25.  
  26. struct DTA
  27. {
  28.    char dummy[21];
  29.    char attribut;
  30.    int  time;
  31.    int  date;
  32.    long size;
  33.    char dat_name[14];
  34. }  dta_buff;
  35.  
  36. #define ARROW           0
  37. #define HOURGLASS       2
  38. #define WF_WORKXYWH     4
  39. #define K_RSHIFT        0x0001
  40. #define K_LSHIFT        0x0002
  41. #define K_CTRL          0x0004
  42. #define K_ALT           0x0008
  43. #define AC_OPEN         40
  44. #define AC_CLOSE        41
  45. #define MU_KEYBD        0x0001
  46. #define MU_BUTTON       0x0002
  47. #define MU_M1           0x0004
  48. #define MU_M2           0x0008
  49. #define MU_MESAG        0x0010
  50. #define MU_TIMER        0x0020
  51.  
  52. struct Aufnahme
  53. {
  54.     int  eventart;
  55.     long eventparameter;
  56.     int  filler;
  57. };
  58. long    eintraege;
  59. struct  Aufnahme        *puffer;
  60.  
  61. #define DEFAULT_SPEED   100
  62. int     speed;
  63. #define GEFUELLT_SPEICHER       0
  64. #define LEER_SPEICHER           1
  65. #define KEIN_SPEICHER           2
  66. int     leer;
  67.  
  68. char    f_path[82],
  69.         f_name[82],
  70.         search[6],
  71.         f_anwahl[82];
  72.  
  73. #define BOOTDATEI       "C:\AUTOEXEC.EVN"
  74. #define WAIT_DEFAULT    5000
  75. int     contrl[12],
  76.         intin[128],
  77.         intout[128],
  78.         ptsin[128],
  79.         ptsout[128];
  80.         
  81. int     handle,
  82.         phys_handle;
  83.         
  84. int     gl_hchar,
  85.         gl_wchar,
  86.         gl_hbox,
  87.         gl_wbox;
  88.         
  89. int     xdesk,
  90.         ydesk,
  91.         wdesk,
  92.         hdesk;
  93.         
  94. int     x_aufl,
  95.         y_aufl,
  96.         bitplanes;
  97.         
  98. extern  int     gl_apid;
  99. int     menu_id;
  100.         
  101. int     dummy;
  102.  
  103.  
  104. /* Initialisierungen für GEM-Programme */
  105.  
  106. _start()
  107. {
  108. form_alert(1,"[1][Dies ist Start][ok]");
  109. }
  110.  
  111. open_vwork()
  112. {
  113.    register     int i;
  114.    appl_init(); 
  115.    if (gl_apid == -1) return FALSE;
  116.    for (i=1; i<10; intin[i++]=1);
  117.    intin[10]=2;
  118.    phys_handle = graf_handle (&gl_wchar, &gl_hchar, &gl_wbox, &gl_hbox);
  119.    
  120.    intin[0] = handle = phys_handle;
  121.    v_opnvwk(intin, &handle, intout);
  122.    x_aufl = intout[0];  /* hier steht die Auflösung drin */
  123.    y_aufl = intout[1];
  124.    bitplanes = (intout[13] == 2) ? 1 : ((intout[13] == 4) ? 2 : 4);
  125.    
  126.    vqt_attributes(handle, intout);
  127.    gl_wchar = intout[6];        /* Werte graf_handle waren falsch */
  128.    gl_hchar = intout[7];
  129.    gl_wbox  = intout[8];
  130.    gl_hbox  = intout[9];
  131.    wind_get(0, WF_WORKXYWH, &xdesk, &ydesk, &wdesk, &hdesk);
  132.    return TRUE;
  133. }
  134.  
  135. close_vwork()
  136. {
  137.    v_clsvwk(handle);
  138.    appl_exit();
  139. }
  140.  
  141. main()
  142. {
  143.    if ( open_vwork() == TRUE )
  144.    {
  145.       if(( menu_id = menu_register( gl_apid,"  Recorder\277 ")) == -1 )
  146.       {
  147.          puts("Acc-Recorder kann nicht installiert werden!");;
  148.          appl_exit();
  149.       }
  150.       else
  151.       {
  152.          /* puts("Acc-Recorder installiert!");; */
  153.          endlos();
  154.       }
  155.       close_vwork();
  156.    }
  157.    else puts("Acc-Recorder: Fehler bei Programminitialisierung!");
  158.         return 0;
  159. }
  160.  
  161. /* Wieviel Speicher wird verbraucht? */
  162.  
  163. long config()
  164. {
  165.    register int  antwort;
  166.    char s[220];
  167.    register long max = (long)Malloc(-1L) / sizeof(struct Aufnahme),
  168.                  anzahl = 0;
  169.  
  170.    do
  171.    {
  172.       anzahl += 1024; /* bei jedem Durchlauf 1 KB dazu */
  173.       if ( anzahl > max ) anzahl = max; /* mehr ist nicht da */
  174.       sprintf (s,
  175.          "[2][%s|%s|%s|%s|%7ld kByte][%ld|mehr|Abbruch]",
  176.          "Event-Recorder\277 V1.0 \21\31\30\31",
  177.          "     by D. Schaun", 
  178.          "Gewünschte \"Bandlänge\"?",
  179.          "Aktueller Speicherbedarf:",
  180.          ( (sizeof(struct Aufnahme) * anzahl) + 512 ) >> 10,
  181.          anzahl );
  182.       antwort = form_alert( 1, s );
  183.    }
  184.    while( antwort == 2 );        /* solange mehr gewünscht */
  185.    if( antwort == 3 ) return 0;  /* Abbruch */
  186.    return anzahl;
  187. }
  188.  
  189. recorder(state)
  190. int state;
  191. {
  192.    char s[220];
  193.    register int antwort;
  194.  
  195.    evnt_timer( 0, 0 );          /* 0 Millisekunden warten */
  196.    if( state & K_RSHIFT ||      /* SHIFT rechts oder */
  197.        state & K_LSHIFT )       /* SHIFT lins */
  198.    {
  199.       if( leer != KEIN_SPEICHER )       /* Speicher vorhanden? */
  200.       {
  201.          if( 1 == form_alert( 1,
  202.             "[2][Speicher wieder|zurückgeben?][Her damit|Behalt' ihn]" ) )
  203.          {
  204.             Mfree( puffer );
  205.             leer = KEIN_SPEICHER;
  206.          }
  207.       }
  208.       else form_alert( 1, "[1][Ich habe|keinen|Speicher!][Na dann]" );
  209.       return;
  210.    }
  211.    if( state & K_CTRL )         /* CTRL-Taste => IO */
  212.    {
  213.       if( leer == GEFUELLT_SPEICHER )   /* Laden/Speicher möglich? */
  214.          antwort = form_alert( 1,
  215.          "[2][Datentransfer|Welche Operation?][Abbruch|Laden|Speicher]");
  216.       else                      /* Speicher leer? nur Laden möglich */
  217.          antwort = form_alert( 1,
  218.          "[2][Datentransfer][Abbruch|Laden]" );
  219.       if( antwort == 1 ) return;        /* Abbruch */
  220.       if( do_file( f_path, f_name, search, f_anwahl ) )
  221.       {
  222.          register int datei;
  223.          if( antwort == 2 )             /* Laden */
  224.          {
  225.             Fsetdta( &dta_buff );
  226.             Fsfirst( f_anwahl, 0 );     /* Filelänge ermittels */
  227.             if( leer != KEIN_SPEICHER )
  228.             {
  229.                Mfree( puffer );
  230.                leer = KEIN_SPEICHER;
  231.             }
  232.             /* Gesamte Datei laden */
  233.             puffer = (struct Aufnahme *)Malloc( dta_buff.size );
  234.             if( !puffer )
  235.             {
  236.                form_alert( 1,
  237.                "[1][Datei paßt|nicht in|den Speicher!][Abbruch]" );
  238.                return;
  239.             }
  240.             leer = LEER_SPEICHER;  /* Speicher ist nun vorhanden */
  241.             datei = Fopen( f_anwahl, 0 );
  242.             if( datei < 0 )
  243.             {
  244.                sprintf( s,
  245.                   "[1][Die Datei|%s|%s|Fehlercode %d][Abbruch]",
  246.                   f_anwahl,
  247.                   "kann nicht gelesen werden!",
  248.                   datei );
  249.                form_alert(1, s );
  250.                return;
  251.             }
  252.             graf_mouse( HOURGLASS, &dummy );
  253.             Fread( datei, (long)sizeof(speed), &speed );
  254.             if( speed > 10000 || speed < 1 ) speed = 100;
  255.             Fread( datei, dta_buff.size, puffer );      /* alles einlesen */
  256.             eintraege = dta_buff.size / sizeof(struct Aufnahme);
  257.             leer = GEFUELLT_SPEICHER;
  258.          }
  259.          else           /* Speichern */
  260.          {
  261.             datei = Fcreate( f_anwahl, 0 );
  262.             if( datei < 0 )
  263.             {
  264.                sprintf( s,
  265.                   "[1][Die Datei|%s|%s|Fehlercode %d][Abbruch]",
  266.                   f_anwahl,
  267.                   "kann nicht erzeugt werden!",
  268.                   datei );
  269.                form_alert(1, s );
  270.                return;
  271.             }
  272.             graf_mouse( HOURGLASS, &dummy );
  273.             Fwrite( datei, (long)sizeof(speed), &speed );
  274.             Fwrite( datei, sizeof(struct Aufnahme) * eintraege, puffer );
  275.          }
  276.          Fclose( datei );
  277.          graf_mouse( ARROW, &dummy );
  278.       } /* Abbruch-Knopf ausgewählt */
  279.       return;
  280.    }
  281.    if( state & K_ALT )          /* ALT-Taste => Speed */
  282.    {
  283.       do /* Nicht für größere Änderungen gedacht */
  284.       {
  285.          sprintf( s, "[2][%s|%s| |%s %4d][Schneller|Langsamer|OK]",
  286.             "Abspielgeschwindigkeit",
  287.             "einstellen! (1 - 10000)",
  288.             "Aktuell:", speed );
  289.          antwort = form_alert( 1, s );
  290.          if( antwort == 1 )
  291.          {
  292.             speed <<= 1;     /* Verdoppeln */
  293.             if( speed > 10000 ) speed = 1;
  294.          }
  295.          if( antwort == 2 )
  296.          {
  297.             speed >>=1;      /* Halbieren */
  298.             if( speed < 1 )     speed = 10000;
  299.          }
  300.       } while( antwort != 3 );
  301.       return;
  302.    }
  303.    if( leer == KEIN_SPEICHER )
  304.    {
  305.       eintraege = config();     /* Wieviele Einträge? */
  306.       if( !eintraege ) return;
  307.       puffer = (struct Aufnahme *)Malloc( sizeof(struct Aufnahme) * eintraege );
  308.       if( !puffer )             /* haben wir den Speicher bekommen? */
  309.       {
  310.          form_alert( 1,
  311.             "[1][Dafür reicht|der Speicher nicht!][Abbruch]" );
  312.          return;
  313.       }
  314.       leer = LEER_SPEICHER;
  315.    }
  316.    if( leer != KEIN_SPEICHER )
  317.    {
  318.       if( leer == LEER_SPEICHER )
  319.       {
  320.          sprintf( s, "[2][%s| |%s|%s|%s][Noch nicht|Aufnahme]",
  321.             "Die erste Aufnahme?",
  322.             "Nach Anklicken von",
  323.             " \"Aufnahme\" geht",
  324.             "   es SOFORT los!" );
  325.          antwort = form_alert( 1, s );
  326.       }
  327.       else
  328.          antwort = form_alert( 2,
  329.             "[2][Was wird gewünscht?][Nichts|Aufnahme|Abspielen]" );
  330.       if( antwort == 1 ) return;
  331.       play_record( antwort == 3 );
  332.    }
  333. }
  334.  
  335. /* Flag mit 0=Aufnahme, 1=Abspielen */
  336. play_record( play )
  337. register int play;
  338. {
  339.    /* in Blöcken zu 16 KB aufspalten,
  340.       ab 32 KB bekommt GEM Probleme */
  341.    long ges = eintraege * sizeof(struct Aufnahme);
  342.    register long vollstaendige = ges >> 14,
  343.                  ptr = (long)puffer;
  344.    int  rest = ges & 0x3FFF,
  345.         anz  = 16384 / sizeof(struct Aufnahme); /* Elemente in 16 KB */
  346.  
  347.    BING;
  348.    /* Ruhe, Aufnahme läuft! */
  349.    while( vollstaendige-- )      /* komplette 16-KB-Blöcke */
  350.    {
  351.       if( play ) appl_tplay( ptr, anz, speed );
  352.       else       appl_trecord( ptr, anz );
  353.       ptr += 16384;
  354.    }
  355.    /* den letzten Schnippel auch noch */
  356.    if( rest )
  357.       if( play ) appl_tplay( ptr, rest / sizeof(struct Aufnahme), speed );
  358.       else       appl_trecord( ptr, rest / sizeof(struct Aufnahme) );
  359.    BING;
  360.    if( !play )          /* Aufnahme beendet */
  361.    {
  362.       form_alert( 1, "[3][Danke, das war's][Stop]" );
  363.       leer = GEFUELLT_SPEICHER;
  364.    }
  365. }
  366.  
  367. bootload( boot_datei )          /* Bootdatei laden, falls vorhanden */
  368. register char *boot_datei;      /* keine Fehlermeldungen!! */
  369. {
  370.    register int datei;
  371.  
  372.    Fsetdta( &dta_buff );
  373.    if( Fsfirst( boot_datei, 0 ) || dta_buff.size <= 2 ) return;
  374.    puffer = (struct Aufnahme *)Malloc( dta_buff.size );
  375.    if( !puffer ) return;
  376.    leer = LEER_SPEICHER;
  377.    datei = Fopen( boot_datei, 0 );
  378.    if( datei < 0 ) return;
  379.    Fread( datei, (long)sizeof(speed), &speed );
  380.    if( speed > 10000 || speed < 1 ) speed = 100;
  381.    Fread( datei, dta_buff.size, puffer );
  382.    Fclose( datei );
  383.    eintraege = dta_buff.size / sizeof(struct Aufnahme);
  384.    leer = GEFUELLT_SPEICHER;
  385.    evnt_timer( WAIT_DEFAULT, 0 );       /* Warten auf Desktop Aufbau */
  386.    play_record( 1 );
  387. }
  388.  
  389. endlos()
  390. {
  391.    int event,
  392.        keycode,
  393.        state,           /* Status der Zusatztasten SHIFT und ALT */
  394.        msgbuff[8];
  395.  
  396.    speed = DEFAULT_SPEED;
  397.    leer = KEIN_SPEICHER;
  398.    *f_path = EOS;
  399.    *f_name = EOS;
  400.    strcpy( search, ".EVN" );
  401.    bootload( BOOTDATEI );       /* wenn vorhanden laden */
  402.    while( TRUE )                /* forever */
  403.    {
  404.       event = evnt_multi( MU_MESAG | MU_BUTTON | MU_KEYBD,
  405.                            1, 1, 1,
  406.                            0, 0, 0, 0, 0,
  407.                            0, 0, 0, 0, 0,
  408.                      msgbuff, 0, 0, &dummy, &dummy, &dummy, &state,
  409.                            &keycode, &dummy ); 
  410.  
  411.       /* unser ACC ausgewählt ? */
  412.       if( event & MU_MESAG      &&
  413.           msgbuff[0] == AC_OPEN &&
  414.           msgbuff[4] == menu_id )  recorder( state );
  415.    }
  416. }
  417.  
  418. /* Name:        do_file    (04.12.87)
  419.    Parameter:   f_path, f_name, search, f_anwahl (Strings)
  420.                 f_path    Vorschlag des Paths
  421.                 f_name    Dateiname im "Auswahl:"-Feld
  422.    Rückgabewerte: Taste (0=ABBRUCH, 1=OK) mit return
  423.                 f_path    Aktueller Path zum Directory
  424.                 f_name    Dateiname ohne Extension
  425.                 f_anwahl  kompletter Pfad incl. Name und Extension
  426.    Funtion:     Läßt Benutzer einen Dateinamen auswählen
  427. */
  428. #define EOS '\0'
  429. extern  long    gemdos();
  430. #define Dgetdrv()       (int)gemdos(0x19)
  431. #define Dgetpath(a,b)   gemdos(0x47,a,b)
  432. #define Dsetdrv(a)      gemdos(0x0e,a)
  433. #define Dsetpath(a)     gemdos(0x3b,a)
  434.  
  435. do_file( f_path, f_name, search, f_anwahl )
  436. register char *f_path, *f_name;
  437. char *search, *f_anwahl;
  438. {
  439.    char help_path[64],
  440.         help_name[64];
  441.    int  key;
  442.    register int i;
  443.  
  444.    if(( i = index( f_path, '*' )) >= 0 )   f_path[i] = EOS;
  445.    strcpy( help_path, f_path );
  446.    strcpy( help_name, f_name );
  447.    if( !f_path[0] )   get_path( f_path );
  448.    strcat( f_path, "*" );
  449.    strcat( f_path, search );
  450.    fsel_input( f_path, f_name, &key );
  451.    if( !f_name[0] || f_name[0] == '.' )   key = 0;
  452.    if( key )
  453.    {
  454.       register int j;
  455.       i = rindex( f_path, '\\' );
  456.       if( i >= 0 )   f_path[++i] = EOS;
  457.       do        /* Pfadname von Blitter-TOS-Bug befreien */
  458.       {
  459.          i = index( f_path, '.' );
  460.          if( i >= 0 && f_path[i+1] == '\\' )
  461.          {
  462.             strcpy( &f_path[i], &f_path[i+1] );
  463.             j = 1;
  464.          }
  465.          else
  466.             j = 0;
  467.       } while( j );
  468.       strcpy( f_anwahl, f_path );
  469.       /* Macke des Blitter-TOS ("XXXXXXXX.") */
  470.       if( strlen( f_name ) == 9 && f_name[8] == '.' )   f_name[8] = EOS;
  471.       strcat( f_anwahl, f_name );
  472.       if( (i = index( f_name, '.' )) >= 0 )   f_name[i] = EOS;
  473.    }
  474.    else
  475.    {
  476.       strcpy( f_path, help_path );
  477.       strcpy( f_name, help_name );
  478.       f_anwahl[0] = EOS;
  479.    }
  480.    return( key );
  481. }
  482.  
  483. get_path( path )
  484. register char *path;
  485. {
  486.    register int fehler;
  487.  
  488.    path[0] = Dgetdrv() + 'A';
  489.    path[1] = ':';
  490.    fehler = Dgetpath( &path[2], 0 );
  491.    strcat( path, "\\" );
  492.    return fehler;
  493. }
  494.  
  495. index( s, c )
  496. register char s[];
  497. register char c;
  498. {
  499.    register int i = 0;
  500.    while( s[i] && s[i] != c )  i++;
  501.    if( s[i] )  return i;
  502.    return -1;
  503. }
  504.  
  505. rindex( s, c )
  506. register char s[];
  507. register char c;
  508. {
  509.    register int i = strlen(s);
  510.    while( i >= 0 && s[i] != c )  i--;
  511.    return i;
  512. }
  513.